Add 'indirect_sort' by mclow · Pull Request #117 · boostorg/algorithm

mclow · 2023-06-15T01:36:09Z

No description provided.

Flamefire

Looks potentially useful.

Added some ideas for improving the description and pointed out a few places for improvement/typo-fixing.

Flamefire · 2023-06-15T08:31:52Z

+There are times that you want a sorted version of a sequence, but for some reason or another, you don't really want to sort them.  Maybe the elements in the sequence are non-copyable (or non-movable), or the sequence is const, or they're just really expensive to move around.   An example of this might be a sequence of records from a database.
+
+Nevertheless, you might want to sort them.  That's where indirect sorting comes in.  In a "normal" sort, the elements of the sequence to be sorted are shuffled in place.  In indirect sorting, the elements are unchanged, but the sort algorithm returns to you a "permutation" of the elements that, when applied, will leave the elements in the sequence in a sorted order.


How about this a bit shorter wording especially avoiding to mention the need to sort twice:

Suggested change

There are times that you want a sorted version of a sequence, but for some reason or another, you don't really want to sort them. Maybe the elements in the sequence are non-copyable (or non-movable), or the sequence is const, or they're just really expensive to move around. An example of this might be a sequence of records from a database.

Nevertheless, you might want to sort them. That's where indirect sorting comes in. In a "normal" sort, the elements of the sequence to be sorted are shuffled in place. In indirect sorting, the elements are unchanged, but the sort algorithm returns to you a "permutation" of the elements that, when applied, will leave the elements in the sequence in a sorted order.

There are times that you want a sorted version of a sequence, but for some reason you don't want to modify it. Maybe the elements in the sequence can't be moved/copied, e.g. the sequence is const, or they're just really expensive to move around. An example of this might be a sequence of records from a database.

That's where indirect sorting comes in. In a "normal" sort, the elements of the sequence to be sorted are shuffled in place. In indirect sorting, the elements are unchanged, but the sort algorithm returns a "permutation" of the elements that, when applied, will put the elements in the sequence in a sorted order.

Are the double-spaces after each sentence intended?

Flamefire · 2023-06-15T08:32:57Z

+
+Nevertheless, you might want to sort them.  That's where indirect sorting comes in.  In a "normal" sort, the elements of the sequence to be sorted are shuffled in place.  In indirect sorting, the elements are unchanged, but the sort algorithm returns to you a "permutation" of the elements that, when applied, will leave the elements in the sequence in a sorted order.
+
+Say you have a sequence `[first, last)` of 1000 items that are expensive to swap:


Suggested change

Say you have a sequence `[first, last)` of 1000 items that are expensive to swap:

Assume a sequence `[first, last)` of 1000 items that are expensive to swap:

Flamefire · 2023-06-15T08:34:16Z

+
+#include <algorithm>        // for std::sort (and others)
+#include <functional>       // for std::less
+#include <vector>           // for std:;vector


Typo:

Suggested change

#include <vector> // for std:;vector

#include <vector> // for std::vector

But is that comment really required?

Flamefire · 2023-06-15T08:35:14Z

+///
+
+#ifndef BOOST_ALGORITHM_IS_INDIRECT_SORT
+#define BOOST_ALGORITHM_IS_INDIRECT_SORT


Unusual include guard. Why not BOOST_ALGORITHM_INDIRECT_SORT?

Flamefire · 2023-06-15T08:36:28Z

+/// \fn indirect_sort (RAIterator first, RAIterator las )
+/// \returns a permutation of the elements in the range [first, last)
+///     such that when the permutation is applied to the sequence,
+///     the result is sorted according to the predicate pred.


Suggested change

/// the result is sorted according to the predicate pred.

/// the result is sorted in non-descending order.

Flamefire · 2023-06-15T08:38:45Z

+/// \param last   The end of the input sequence
+///
+template <typename RAIterator>
+std::vector<size_t> indirect_sort (RAIterator first, RAIterator last) {


Suggested change

std::vector<size_t> indirect_sort (RAIterator first, RAIterator last) {

Permutation indirect_sort (RAIterator first, RAIterator last) {

Flamefire · 2023-06-15T08:40:49Z

+
+
+void test_sort () {
+    BOOST_CXX14_CONSTEXPR int num[] = { 1,3,5,7,9, 2, 4, 6, 8, 10 };


Suggested change

BOOST_CXX14_CONSTEXPR int num[] = { 1,3,5,7,9, 2, 4, 6, 8, 10 };

int num[] = { 1,3,5,7,9, 2, 4, 6, 8, 10 };

or int *first = &num[0]; is invalid isn't it?

Flamefire · 2023-06-15T08:41:33Z

+
+// A permutation of size N is a sequence of values in the range [0..N)
+// such that no value appears more than once in the permutation.
+bool isa_permutation(Permutation p, size_t N) {


Suggested change

bool isa_permutation(Permutation p, size_t N) {

bool is_a_permutation(Permutation p, size_t N) {

is more readable.

Flamefire · 2023-06-15T08:43:39Z

+	test_one_sort(v.begin(), v.end(), std::greater<int>());
+    }
+
+BOOST_AUTO_TEST_CASE( test_main )


Why that extra method and not using BOOST_AUTO_TEST_CASE(test_sort) directly?

Because I expect there to be more test cases in the future.

But the whole idea of BOOST_AUTO_TEST_CASE is that you simply "decorate" each test case with that and NOT have a "main" function. By default it will run each such function sequentially even allowing you to filter test based on their name from the CLI.

-->

BOOST_AUTO_TEST_CASE( test_sort ){ ... } BOOST_AUTO_TEST_CASE( test_indirect_stable_sort ){ ... }

Flamefire · 2023-06-15T08:44:27Z

@@ -0,0 +1,100 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.


Suggested change

Copyright (c) Marshall Clow 2011-2012.

Copyright (c) Marshall Clow 2023.

…'nth_element'

Flamefire · 2023-06-21T07:54:30Z

+	return ret;
+}
+
+/// \fn indirect_partial_sort (RAIterator first, RAIterator last)


C&P mistake in the signature inside this (and below) docstrings

Flamefire · 2023-06-21T07:54:50Z

+/// \fn indirect_nth_element (RAIterator first, RAIterator last, Predicate p)
+/// \returns a permutation of the elements in the range [first, last)
+///     such that when the permutation is applied to the sequence,
+///     the result is sorted according to the predicate pred.


Similar C&P mistake in signature and description.

Nice catch - thanks!

nigels-com · 2026-04-12T11:39:08Z

I've implemented something similar for a recent project.
A few thoughts to note.

Would like to used uint32_t for "small" jobs less than ~4 billion items
Would like to use this in combination with other sort algorithms such as boost::sort
Would like to use pre-existing permutation as an option, rather than always re-allocate one

Add 'indirect_sort'

17c47e8

Flamefire reviewed Jun 15, 2023

View reviewed changes

mclow added 3 commits June 18, 2023 11:31

Update docs based on feedback, add 'stable_sort', 'partial_sort' and …

814f8a5

…'nth_element'

Add more tests

3ae9ee2

Split test cases

8be54b3

Flamefire suggested changes Jun 21, 2023

View reviewed changes

mclow added 3 commits June 23, 2023 19:32

Update docs; fix copy-pasta

a7ae53d

Replace call to 'iota' with hand-rolled loop

25ab833

Replace hand-rolled loop with 'iota_n' and back_insert_iterator

62922bd

		There are times that you want a sorted version of a sequence, but for some reason or another, you don't really want to sort them. Maybe the elements in the sequence are non-copyable (or non-movable), or the sequence is const, or they're just really expensive to move around. An example of this might be a sequence of records from a database.

		Nevertheless, you might want to sort them. That's where indirect sorting comes in. In a "normal" sort, the elements of the sequence to be sorted are shuffled in place. In indirect sorting, the elements are unchanged, but the sort algorithm returns to you a "permutation" of the elements that, when applied, will leave the elements in the sequence in a sorted order.


		Nevertheless, you might want to sort them. That's where indirect sorting comes in. In a "normal" sort, the elements of the sequence to be sorted are shuffled in place. In indirect sorting, the elements are unchanged, but the sort algorithm returns to you a "permutation" of the elements that, when applied, will leave the elements in the sequence in a sorted order.

		Say you have a sequence `[first, last)` of 1000 items that are expensive to swap:

	Say you have a sequence `[first, last)` of 1000 items that are expensive to swap:
	Assume a sequence `[first, last)` of 1000 items that are expensive to swap:

	#include <vector> // for std:;vector
	#include <vector> // for std::vector

	/// the result is sorted according to the predicate pred.
	/// the result is sorted in non-descending order.

	std::vector<size_t> indirect_sort (RAIterator first, RAIterator last) {
	Permutation indirect_sort (RAIterator first, RAIterator last) {



		void test_sort () {
		BOOST_CXX14_CONSTEXPR int num[] = { 1,3,5,7,9, 2, 4, 6, 8, 10 };

	BOOST_CXX14_CONSTEXPR int num[] = { 1,3,5,7,9, 2, 4, 6, 8, 10 };
	int num[] = { 1,3,5,7,9, 2, 4, 6, 8, 10 };

	bool isa_permutation(Permutation p, size_t N) {
	bool is_a_permutation(Permutation p, size_t N) {

	Copyright (c) Marshall Clow 2011-2012.
	Copyright (c) Marshall Clow 2023.

Conversation

mclow commented Jun 15, 2023

Uh oh!

Flamefire left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

nigels-com commented Apr 12, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

nigels-com commented Apr 12, 2026 •

edited

Loading